package com.snj.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author yujie
 * @data 2024/8/21 8:24
 */
public class Demo {
    public static void main(String[] args) {
        Map<String, List<Integer>> mapList = new HashMap<>();
        List<Integer> oneList = new ArrayList<>();
        List<Integer> twoList = new ArrayList<>();

        // 先 确定一个总的人数
        // 数量
        int oneDept = 25;
        int twoDept = 13;
        // 要求在 5 - 13 之间(并且是奇数)
        // 让 oneDept， twoDept 除 13 得到这两个数 的余数

        // 计算整除结果
        int quotientOneDept = oneDept / 13;
        if (quotientOneDept > 0) {
            for (int i = 0; i < quotientOneDept; i++) {
                oneList.add(13);
            }
        }
        int quotientTwoDept = twoDept / 13;
        if (quotientTwoDept > 0) {
            for (int i = 0; i < quotientTwoDept; i++) {
                twoList.add(13);
            }
        }

        int remainderOneDept = oneDept % 13;
        int remainderTwoDept = twoDept % 13;
        // 判断 余数 是否在  大于等于 5 小于等于13
        // 如果在 判断其是否为奇数
        // 判断余数是否在 5 到 13 之间（包括5和13），并且是奇数
        // 标记剩余人数
        int oneFlag = 0;
        boolean isValidOneDept = isValidRemainder(remainderOneDept);
        if (isValidOneDept) {
            oneList.add(remainderOneDept);
        } else {
            // 余数不是 奇数
            // 判断余数是否大于5
            if (remainderOneDept > 5) {
                int[] ints = findTwoOddNumbers(remainderOneDept);
                if (ints.length > 1) {
                    for (int i = 0; i < ints.length; i++) {
                        oneList.add(ints[i]);
                    }
                } else {
                    for (int i = 0; i < ints.length; i++) {
                        oneList.add(ints[i]);
                    }
                    // 这里最后肯定留下的是 1
                    oneFlag = 1;
                }
            } else {
                oneFlag = remainderOneDept;
            }
        }

        // 标记剩余人数
        int twoFlag = 0;
        boolean isValidTwoDept = isValidRemainder(remainderTwoDept);
        if (isValidTwoDept) {
            twoList.add(remainderTwoDept);
        } else {
            if (remainderTwoDept > 5) {
                int[] ints = findTwoOddNumbers(remainderTwoDept);
                if (ints.length > 1) {
                    for (int i = 0; i < ints.length; i++) {
                        twoList.add(ints[i]);
                    }
                } else {
                    for (int i = 0; i < ints.length; i++) {
                        twoList.add(ints[i]);
                    }
                    // 这里最后肯定留下的是 1
                    twoFlag = 1;
                }
            } else {
                twoFlag = remainderTwoDept;
            }
        }

        System.out.println("1剩余人数: " + oneFlag);
        System.out.println("2剩余人数: " + twoFlag);
        mapList.put("施工", oneList);
        mapList.put("服务", twoList);

        // 判断是 那一块 剩余 出了人数
        int totalFlag = 0;
        if (oneFlag > 0) {
            List<Integer> list = mapList.get("施工");
            if (!list.isEmpty()) {
                // 判断 分组值，加上剩余值 是否大于 13
                int index = 0;
                for (Integer i : list) {
                    if (i < 13) {
                        if (i + oneFlag < 13) {
                            // 判断是否是奇数
                            boolean validJiShu = isValidJiShu(i + oneFlag);
                            if (validJiShu) {
                                list.set(index, i + oneFlag);
                            } else {
                                list.set(index, i + oneFlag + 1);
                            }
                        } else {
                            // 大于 13
                            list.set(index, 13);
                            totalFlag += i + oneFlag - 13;
                        }
                    }
                    index += 1;
                }
            }
        }

        if (twoFlag > 0) {
            List<Integer> list = mapList.get("服务");
            if (!list.isEmpty()) {
                // 判断 分组值，加上剩余值 是否大于 13
                int index = 0;
                int tempFlag = 0;
                for (Integer i : list) {
                    if (i < 13) {
                        if (i + twoFlag < 13) {
                            // 判断是否是奇数
                            boolean validJiShu = isValidJiShu(i + twoFlag);
                            if (validJiShu) {
                                list.set(index, i + twoFlag);
                            } else {
                                list.set(index, i + twoFlag + 1);
                            }
                        } else {
                            // 大于 13
                            list.set(index, 13);
                            totalFlag += i + twoFlag - 13;
                        }
                    }
                    index += 1;
                }
            }
        }

        System.out.println("总剩余: " + totalFlag);
        System.out.println(mapList);
    }

    // 判断余数是否在 5 到 13 之间（包括5和13），并且是奇数
    private static boolean isValidRemainder(int remainder) {
        return remainder >= 5 && remainder <= 13 && remainder % 2 != 0;
    }

    private static boolean isValidJiShu(int remainder) {
        return remainder % 2 != 0;
    }

    // 查找两个奇数的和等于 input 的值，或返回最接近13的奇数
    private static int[] findTwoOddNumbers(int input) {
        // 确保输入在5到13之间
        if (input < 5 || input > 13) {
            throw new IllegalArgumentException("输入值必须在5到13之间");
        }

        // 奇数数组
        int[] oddNumbers = {5, 7, 9, 11, 13};

        // 寻找两个奇数
        for (int i = 0; i < oddNumbers.length; i++) {
            for (int j = i; j < oddNumbers.length; j++) {
                if (oddNumbers[i] + oddNumbers[j] == input) {
                    return new int[]{oddNumbers[i], oddNumbers[j]};
                }
            }
        }

        // 如果没有找到两个奇数，则返回最接近13的奇数
        return new int[]{(input - 1)};
    }
}
